package mysql

import (
	"errors"
	"log"
	"net/http"
	"project3/model"
	"strconv"

	"github.com/gin-gonic/gin"
	_ "github.com/go-sql-driver/mysql"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
)

// DB 是一个全局的gorm.DB对象，用于在程序的多个地方共享数据库连接
var DB *gorm.DB

// Mysql1 初始化数据库连接并迁移表结构
func Mysql1() {
	// DSN 是连接数据库的信息字符串
	dsn := "root:root@tcp(127.0.0.1:3306)/students?charset=utf8mb4&parseTime=True&loc=Local"

	// 初始化数据库连接
	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{})
	if err != nil {
		// 如果连接失败，打印错误并退出程序
		log.Fatalf("无法连接到数据库: %v", err)
	}

	// 自动迁移表结构，即根据模型自动创建或更新数据库表
	db.AutoMigrate(&model.Students{})
	db.AutoMigrate(&model.Class{})
	db.AutoMigrate(&model.Courses{})
	db.AutoMigrate(&model.Grades{})
	db.AutoMigrate(&model.Teachers{})
	db.AutoMigrate(&model.User{})

	// 尝试获取底层SQL数据库连接
	sqlDB, err := db.DB()
	if err != nil {
		// 如果获取失败，打印错误并退出程序
		log.Fatalf("无法获取底层数据库连接: %v", err)
	}

	// 设置连接池中的最大空闲连接数
	sqlDB.SetMaxIdleConns(10)
	// 设置连接池中的最大打开连接数
	sqlDB.SetMaxOpenConns(100)
	// 设置连接的最大生命周期
	sqlDB.SetConnMaxLifetime(0) //如果设置为0，表示存活时间无限大

	// 将初始化好的数据库连接赋值给全局变量DB
	DB = db
}

// GetDB 函数返回一个指向gorm.DB的指针，用于数据库操作
// 如果DB为nil（即未初始化），则记录致命错误并退出程序
func GetDB() *gorm.DB {
	if DB == nil {
		log.Fatal("数据库连接未初始化") // 如果DB为nil，则记录错误并退出
	}
	return DB // 返回数据库连接指针
}

// Create 函数处理添加新学生的请求
func Create(c *gin.Context) {
	var asset model.Students                         // 定义一个Students结构体变量用于接收JSON数据
	if err := c.ShouldBindJSON(&asset); err != nil { // 尝试将请求体中的JSON数据绑定到asset变量上
		c.JSON(400, gin.H{"error": err}) // 如果绑定失败，返回400状态码和错误信息
		return
	}

	if DB == nil { // 检查数据库连接是否已初始化
		c.JSON(500, gin.H{"error": "数据库连接失败"}) // 如果未初始化，返回500状态码和错误信息
		return
	}

	// 尝试将asset变量中的数据插入到数据库中
	if err := DB.Create(&asset).Error; err != nil { // 使用gorm的Create方法插入数据，并检查是否有错误
		c.JSON(500, gin.H{"error": err}) // 如果有错误，返回500状态码和错误信息
		return
	}

	// 如果插入成功，返回201状态码和成功信息以及插入的数据
	c.JSON(201, gin.H{
		"message": "学生添加成功",
		"asset":   asset,
	})
}

// Delete 函数处理删除学生的请求
func Delete(c *gin.Context) {
	id := c.Param("Student_id") // 从URL参数中获取学生ID

	// 尝试根据ID删除学生数据
	result := DB.Where("Student_id=?", id).Delete(&model.Students{})

	if result.Error != nil { // 检查是否有错误发生
		c.JSON(500, gin.H{"msg": "删除失败: " + result.Error.Error()}) // 如果有错误，返回500状态码和错误信息
	} else if result.RowsAffected == 0 { // 如果没有行被影响（即没有找到对应ID的学生）
		c.JSON(200, gin.H{"msg": "没有找到ID删除失败"}) // 返回200状态码和未找到ID的错误信息
	} else { // 如果删除成功
		c.JSON(200, gin.H{"msg": "删除成功"}) // 返回200状态码和成功信息
	}
}

// PUT 函数处理更新学生信息的请求
func PUT(c *gin.Context) {
	var data model.Students // 定义一个Students结构体变量用于接收更新后的数据和查询原始数据

	id := c.Param("Student_id") // 从URL参数中获取学生ID

	// 尝试根据ID查询学生数据
	DB.Select("Student_id").Where("Student_id=?", id).Find(&data)

	// 如果查询到的Student_id为0，说明没有找到对应ID的学生
	if data.Student_id == 0 {
		c.JSON(200, gin.H{"msg": "没有找到ID"}) // 返回200状态码和未找到ID的错误信息
	} else {
		// 尝试将请求体中的JSON数据绑定到data变量上
		err := c.ShouldBindJSON(&data)

		// 如果绑定失败
		if err != nil {
			c.JSON(200, gin.H{"msg": "修改失败"}) // 返回200状态码和修改失败的信息（这里状态码可能应该是400或其他更合适的）
		} else {
			// 使用gorm的Updates方法根据ID更新学生数据
			DB.Where("Student_id=?", id).Updates(&data)

			// 返回200状态码和成功信息
			c.JSON(200, gin.H{"msg": "修改成功"})
		}
	}
}

// 查找学生
func Postname(c *gin.Context) {
	// 从URL中获取名为name的参数值
	name := c.Param("Name")
	// 定义一个UserBasic类型的切片，用于存储查询结果
	var datalist []model.Students
	// 使用GORM的Where方法查询数据库，将name字段等于传入name值的记录查找出来，并将结果存放到datalist切片中
	DB.Where("Name = ?", name).Find(&datalist)

	// 判断查询结果是否为空
	if len(datalist) == 0 {
		// 如果为空，返回JSON响应，状态码为200，内容为"查询失败"
		c.JSON(200, gin.H{
			"msg": "查询失败",
		})
	} else {
		// 如果不为空，返回JSON响应，状态码为200，内容为"查找成功"以及查询到的数据列表datalist
		c.JSON(200, gin.H{
			"msg":  "查找成功",
			"data": datalist,
		})
	}
}

// Createclss 函数用于创建新的班级
func Createclss(c *gin.Context) {
	// 创建一个空的 Class 结构体实例，用于接收从请求中解析的 JSON 数据
	var asset1 model.Class
	// 尝试将请求的 JSON 数据绑定到 asset1 结构体实例上
	if err := c.ShouldBindJSON(&asset1); err != nil {
		// 如果绑定失败，则返回 400 错误，并告知 JSON 绑定失败
		c.JSON(400, gin.H{"error": "JSON绑定失败"})
		return
	}

	// 检查数据库连接是否已建立
	if DB == nil {
		// 如果数据库连接为 nil，则返回 500 错误，并告知数据库连接失败
		c.JSON(500, gin.H{"error": "数据库连接失败"})
		return
	}

	// 尝试在数据库中创建 asset1 结构体对应的记录
	if err := DB.Create(&asset1).Error; err != nil {
		// 如果创建失败，则返回 500 错误，并告知具体的错误原因
		c.JSON(500, gin.H{"error": err})
		return
	}

	// 如果创建成功，则返回 201 状态码，并告知教室添加成功，同时返回添加的班级信息
	c.JSON(201, gin.H{
		"message": "教室添加成功",
		"asset":   asset1,
	})
}

// Deleteclass 函数用于删除指定 ID 的班级
func Deleteclass(c *gin.Context) {
	// 从请求的 URL 参数中获取 Class_id
	idStr := c.Param("Class_id")

	// 尝试将 Class_id 转换为整数
	id, err := strconv.Atoi(idStr)
	if err != nil {
		// 如果转换失败，则返回 400 错误，并告知无效的教室 ID
		c.JSON(400, gin.H{"msg": "无效的教室ID: " + err.Error()})
		return
	}

	// 尝试在数据库中删除指定 ID 的班级
	result := DB.Where("Class_id=?", id).Delete(&model.Class{})

	// 检查删除操作是否成功
	if result.Error != nil {
		// 如果删除失败，则返回 500 错误，并告知具体的错误原因
		c.JSON(500, gin.H{"msg": "删除失败: " + result.Error.Error()})
	} else if result.RowsAffected == 0 {
		// 如果没有找到对应的班级 ID，则返回 200 状态码，并告知没有找到教室 ID
		c.JSON(200, gin.H{"msg": "没有找到教室ID删除失败"})
	} else {
		// 如果删除成功，则返回 200 状态码，并告知教室删除成功
		c.JSON(200, gin.H{"msg": "教室删除成功"})
	}
}

// 更新指定 ID 的班级信息
func PUTclass(c *gin.Context) {
	// 初始化一个空的 Class 结构体实例，用于存储从请求中接收到的更新后的班级信息
	var data model.Class

	// 从请求的 URL 参数中获取要更新的班级ID
	id := c.Param("Class_id")

	// 尝试从数据库中根据ID查询班级信息，并将结果保存到 data 结构体实例中
	if err := DB.Where("Class_id=?", id).First(&data).Error; err != nil {
		// 检查是否因为找不到记录而导致的错误
		if errors.Is(err, gorm.ErrRecordNotFound) {
			// 如果找不到对应的班级ID，则返回404状态码并告知没有找到该班级
			c.JSON(404, gin.H{"msg": "没有找到对应的班级ID"})
		} else {
			// 如果发生其他数据库错误，则返回500状态码并告知数据库查询错误
			c.JSON(500, gin.H{"msg": "数据库查询错误: " + err.Error()})
		}
		return
	}

	// 尝试将客户端发送的JSON数据绑定到 data 结构体实例上，以获取要更新的字段值
	// 注意：此步骤不会覆盖 data 中已经存在的 Class_id 字段
	if err := c.ShouldBindJSON(&data); err != nil {
		// 如果JSON数据绑定失败（格式错误或字段不匹配），则返回400状态码并告知请求数据格式错误
		c.JSON(400, gin.H{"msg": "请求数据格式错误: " + err.Error()})
		return
	}

	// 使用GORM的Save方法更新数据库中的班级记录
	if err := DB.Save(&data).Error; err != nil {
		// 如果更新失败，则返回500状态码并告知更新失败的具体原因
		c.JSON(500, gin.H{"msg": "更新失败: " + err.Error()})
		return
	}

	// 如果班级记录成功更新，则返回200状态码并告知修改成功
	c.JSON(200, gin.H{"msg": "班级信息修改成功"})
}

// QueryClass 函数用于查询指定ID的班级信息
func QueryClass(c *gin.Context) {
	// 从请求的URL参数中获取班级ID
	idStr := c.Param("Class_id")

	// 尝试将班级ID转换为整数
	id, err := strconv.Atoi(idStr)
	if err != nil {
		// 如果转换失败，则返回400错误，并告知无效的班级ID
		c.JSON(400, gin.H{"error": "Invalid Class ID: " + err.Error()})
		return
	}

	// 创建一个空的Class结构体实例，用于存储查询到的班级信息
	var class model.Class

	// 尝试从数据库中查询指定ID的班级信息
	result := DB.Where("Class_id = ?", id).First(&class)

	// 检查查询结果
	if result.Error != nil {
		// 检查错误是否是“记录未找到”错误
		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
			// 如果没有找到对应的班级，则返回404错误，并告知未找到班级
			c.JSON(404, gin.H{"error": "班级未找到"})
			return
		}
		// 如果是其他类型的错误（比如数据库连接问题、查询语法错误等），则返回500错误，并告知具体的错误原因
		c.JSON(500, gin.H{"error": "内部服务器错误: " + result.Error.Error()})
		return
	}

	// 如果查询成功，则返回200状态码，并返回查询到的班级信息
	c.JSON(200, gin.H{"message": "班级已找到", "class": class})
}

// Teacher 函数处理教师添加请求
func Teacher(c *gin.Context) {
	// 定义一个 Teachers 结构体变量来存储 JSON 数据中的教师信息
	var Teacher_id model.Teachers // 通常，这里的变量名可能会更改为 teacher 或其他更具描述性的名称

	// 尝试将请求体中的 JSON 数据绑定到 Teacher_id 结构体变量上
	if err := c.ShouldBindJSON(&Teacher_id); err != nil {
		// 如果绑定失败，则返回400错误和错误信息
		c.JSON(400, gin.H{"error": "失败"})
		return // 绑定失败时直接返回，不再执行后续代码
	}

	// 在数据库中创建新的教师记录
	// 注意：这里的变量名“Teacher_id”可能会引起误解，因为它通常代表一个ID，但这里实际上是一个结构体
	if err := DB.Create(&Teacher_id).Error; err != nil {
		// 如果创建失败，则返回500错误和具体的错误信息
		c.JSON(500, gin.H{"error": err})
		return
	}

	// 创建成功，返回200状态码和包含教师信息的响应体
	c.JSON(200, gin.H{
		"message": "教师添加成功",
		"teacher": Teacher_id, // 这里将添加的教师信息返回给客户端
	})
}

// Deleteteacher 函数处理教师删除请求
func Deleteteacher(c *gin.Context) {
	// 从请求参数中获取教师ID的字符串表示
	idStr := c.Param("Teacher_id")

	// 将教师ID的字符串表示转换为整数类型
	id, err := strconv.Atoi(idStr)
	if err != nil {
		// 如果转换失败，返回400错误和错误信息
		c.JSON(400, gin.H{"msg": "无效的教师ID: " + err.Error()})
		return // 转换失败时直接返回，不再执行后续代码
	}

	// 根据教师ID删除对应的教师记录
	result := DB.Where("Teacher_id=?", id).Delete(&model.Teachers{})

	if result.Error != nil {
		// 如果删除失败，返回500错误和具体的错误信息
		c.JSON(500, gin.H{"msg": "删除失败: " + result.Error.Error()})
	} else if result.RowsAffected == 0 {
		// 如果没有找到对应的教师记录，返回200状态码和提示信息
		c.JSON(200, gin.H{"msg": "没有找到教师ID删除失败"})
	} else {
		// 删除成功，返回200状态码和提示信息
		c.JSON(200, gin.H{"msg": "教师删除成功"})
	}
}

// 修改教师请求
func PUTTeacher(c *gin.Context) {
	var data1 model.Teachers

	id := c.Param("Teacher_id")

	DB.Select("Teacher_id").Where("Teacher_id=?", id).Find(&data1)

	if data1.Teacher_id == 0 {
		c.JSON(200, gin.H{"msg": "没有找到ID"})
	} else {

		err := c.ShouldBindJSON(&data1)

		if err != nil {
			c.JSON(200, gin.H{"msg": "修改失败"})
		} else {

			DB.Where("Teacher_id=?", id).Updates(&data1)

			c.JSON(200, gin.H{"msg": "修改成功"})
		}
	}
}

// 查询教师请求
func QueryTeacher(c *gin.Context) {
	// 获取URL参数中的Name（这里假设你的路由是这样定义的：/teachers/:name）
	name := c.Param("Name")

	// 初始化一个Teachers对象，但我们不会使用它，因为我们直接从参数中获取Name
	var treasher model.Teachers // 注意这里也修复了拼写错误

	// 使用GORM查询数据库
	result := DB.Where("Name = ?", name).First(&treasher)

	if result.Error != nil {
		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
			// 如果记录未找到，返回404
			c.JSON(404, gin.H{"error": "教师未找到"})
			return
		}
		// 如果发生其他错误，返回500
		c.JSON(500, gin.H{"error": "内部服务器错误: " + result.Error.Error()})
		return
	}

	// 如果找到记录，返回200和查询到的教师信息
	c.JSON(200, gin.H{"message": "教师已找到", "teacher": treasher}) // 注意这里也修复了拼写错误
}

// 处理课程添加请求
func AddCourse(c *gin.Context) {
	var course model.Courses

	if err := c.ShouldBindJSON(&course); err != nil {
		c.JSON(400, gin.H{"错误": "无法解析 JSON 数据"})
		log.Println("Error parsing JSON:", err)
		return
	}

	if err := DB.Create(&course).Error; err != nil {
		c.JSON(500, gin.H{"error": "创建课程失败: " + err.Error()})
		log.Println("Error creating course:", err)
		return
	}

	c.JSON(200, gin.H{
		"message": "课程添加成功",
		"course": gin.H{
			"id":         course.Course_id,
			"name":       course.Course_name,
			"code":       course.Course_code,
			"teacher_id": course.Teacher_id,
			"tredits":    course.Tredits,
			"semester":   course.Semester,
		},
	})
}

// Deleteteacher 函数处理课程删除请求
func DeleteCourse(c *gin.Context) {
	// 从请求参数中获取教师ID的字符串表示
	idStr := c.Param("Course_id")

	// 将教师ID的字符串表示转换为整数类型
	id, err := strconv.Atoi(idStr)
	if err != nil {
		// 如果转换失败，返回400错误和错误信息
		c.JSON(400, gin.H{"msg": "无效课程ID: " + err.Error()})
		return // 转换失败时直接返回，不再执行后续代码
	}

	// 根据教师ID删除对应的教师记录
	result := DB.Where("Course_id=?", id).Delete(&model.Courses{})

	if result.Error != nil {
		// 如果删除失败，返回500错误和具体的错误信息
		c.JSON(500, gin.H{"msg": "删除失败: " + result.Error.Error()})
	} else if result.RowsAffected == 0 {
		// 如果没有找到对应的教师记录，返回200状态码和提示信息
		c.JSON(200, gin.H{"msg": "没有找到课程ID删除失败"})
	} else {
		// 删除成功，返回200状态码和提示信息
		c.JSON(200, gin.H{"msg": "课程删除成功"})
	}
}

// 修改课程
func PUTCourse(c *gin.Context) {
	idStr := c.Param("Course_id")
	id, err := strconv.Atoi(idStr)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": "无效的ID格式"})
		return
	}

	// 检查课程是否存在
	var existingCourse model.Courses
	if err := DB.Where("Course_id = ?", id).First(&existingCourse).Error; err != nil {
		if err == gorm.ErrRecordNotFound {
			c.JSON(http.StatusNotFound, gin.H{"msg": "没有找到课程"})
			return
		}
		c.JSON(http.StatusInternalServerError, gin.H{"msg": "数据库查询错误"})
		return
	}

	// 绑定请求体到新的结构体实例
	var newData model.Courses
	if err := c.ShouldBindJSON(&newData); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": "解析请求体失败"})
		return
	}

	// 仅更新请求体中提供的字段（这里假设只更新Name字段，你需要根据实际需求修改）
	updates := map[string]interface{}{
		"Course_id":   newData.Course_id,
		"Course_name": newData.Course_name,
		"Course_code": newData.Course_code,
		"Teacher_id":  newData.Teacher_id,
		"Tredits":     newData.Tredits,
		"Semester":    newData.Semester,
	}

	// 更新数据库
	if err := DB.Model(&existingCourse).Where("Course_id = ?", id).Updates(updates).Error; err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"msg": "数据库更新错误"})
		return
	}

	// 返回成功消息
	c.JSON(http.StatusOK, gin.H{"msg": "修改成功"})
}

// 查询课程
func QueryCourse(c *gin.Context) {
	// 获取URL参数中的Course_id（假设路由是 /courses/:Course_id）
	courseID := c.Param("Course_id")

	// 初始化一个Courses对象用于存储查询到的课程信息
	var course model.Courses

	// 使用GORM查询数据库
	result := DB.Where("Course_id = ?", courseID).First(&course)

	if result.Error != nil {
		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
			// 如果记录未找到，返回404
			c.JSON(404, gin.H{"error": "课程未找到"})
			return
		}
		// 如果发生其他错误，返回500
		c.JSON(500, gin.H{"error": "内部服务器错误: " + result.Error.Error()})
		return
	}

	// 如果找到记录，返回200和查询到的课程信息
	c.JSON(200, gin.H{"message": "课程已找到", "course": course})
}

// Grade 函数处理成绩添加请求
func Grade(c *gin.Context) {
	// 定义一个 Grades 结构体变量来存储 JSON 数据中的成绩信息
	var gradeRecord model.Grades

	// 尝试将请求体中的 JSON 数据绑定到 gradeRecord 结构体变量上
	if err := c.ShouldBindJSON(&gradeRecord); err != nil {
		// 如果绑定失败，则返回400错误和错误信息
		c.JSON(400, gin.H{"error": "无法解析 JSON 数据"})
		log.Println("Error parsing JSON:", err) // 记录错误到服务器日志
		return
	}

	// 在数据库中创建新的成绩记录
	if err := DB.Create(&gradeRecord).Error; err != nil {
		// 如果创建失败，则返回500错误和具体的错误信息
		c.JSON(500, gin.H{"error": "创建成绩记录失败: " + err.Error()})
		log.Println("Error creating grade:", err) // 记录错误到服务器日志
		return
	}

	// 创建成功，返回200状态码和包含成绩信息的响应体
	// 注意：这里我们可能只返回客户端关心的字段，而不是整个结构体
	c.JSON(200, gin.H{
		"message": "成绩添加成功",
		// 可以选择性地返回 gradeRecord 中的字段，例如：
		"grade": gin.H{
			"id":         gradeRecord.Grade_id,
			"student_id": gradeRecord.Student_id,
			"course_id":  gradeRecord.Course_id,
			"Course":     gradeRecord.Course,
			"score":      gradeRecord.Score,
			"semester":   gradeRecord.Semester,
		},
	})
}

// DeleteGrade 函数处理成绩删除请求
func DeleteGrade(c *gin.Context) {
	var data []model.Grades

	// 获取URL中的id参数
	id := c.Param("Grade_id")

	// 根据id查询数据库，并将结果保存到data切片中
	DB.Where("Grade_id=?", id).Find(&data)

	// 如果没有找到对应id的数据
	if len(data) == 0 {
		// 返回错误信息给前端
		c.JSON(200, gin.H{"msg": "没有找到ID删除失败"})
	} else {
		// 根据id删除数据库中的数据
		DB.Where("Grade_id=?", id).Delete(&data)
		// 返回成功信息给前端
		c.JSON(200, gin.H{"msg": "删除成功"})
	}
}

// UpdateGrade 函数处理成绩修改请求
func UpdateGrade(c *gin.Context) {
	idStr := c.Param("Grade_id")
	id, err := strconv.Atoi(idStr)
	if err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": "无效的ID格式"})
		return
	}

	// 检查课程是否存在
	var existingCourse model.Grades
	if err := DB.Where("Grade_id  = ?", id).First(&existingCourse).Error; err != nil {
		if err == gorm.ErrRecordNotFound {
			c.JSON(http.StatusNotFound, gin.H{"msg": "没有找到成绩ID"})
			return
		}
		c.JSON(http.StatusInternalServerError, gin.H{"msg": "数据库查询错误"})
		return
	}

	// 绑定请求体到新的结构体实例
	var newData model.Grades
	if err := c.ShouldBindJSON(&newData); err != nil {
		c.JSON(http.StatusBadRequest, gin.H{"msg": "解析请求体失败"})
		return
	}

	// 仅更新请求体中提供的字段（这里假设只更新Name字段，你需要根据实际需求修改）
	updates := map[string]interface{}{
		"Student_id": newData.Student_id,
		"Course_id":  newData.Course_id, // 注意这里从 Crade_id 更改为 Course_id
		"Course":     newData.Course,
		"Score":      newData.Score,
		"Semester":   newData.Semester,
	}
	// 更新数据库
	if err := DB.Model(&existingCourse).Where("Grade_id = ?", id).Updates(updates).Error; err != nil {
		c.JSON(http.StatusInternalServerError, gin.H{"msg": "数据库更新错误"})
		return
	}

	// 返回成功消息
	c.JSON(http.StatusOK, gin.H{"msg": "修改成功"})
}

// GetAllGrades 函数处理查找所有成绩请求
func GetAllGrades(c *gin.Context) {
	// 定义一个Grades切片来存储查询到的所有成绩信息
	var grades []model.Grades

	// 使用GORM从数据库中查询所有成绩信息
	if err := DB.Find(&grades).Error; err != nil {
		// 如果查询发生错误，返回错误信息
		c.JSON(500, gin.H{"error": "查询成绩时出错: " + err.Error()})
		return
	}

	// 查询成功，返回200状态码和包含所有成绩信息的响应体
	c.JSON(200, gin.H{
		"grades": grades,
	})
}

// GetGradeByID 函数处理查找指定ID成绩请求
func GetGradeByID(c *gin.Context) {
	// 从URL参数中获取要查找的成绩的ID
	idStr := c.Param("Grade_id")
	id, err := strconv.Atoi(idStr)
	if err != nil {
		c.JSON(400, gin.H{"error": "无效的ID参数"})
		return
	}

	// 转换为无符号整数类型，如果id应该是非负的
	var uid uint = uint(id)

	// 定义一个Grade结构体变量来存储查询到的成绩信息
	var grade model.Grades // 假设这是您的单个成绩的结构体名称

	// 在数据库中查询指定ID的成绩记录
	result := DB.First(&grade, uid)
	if result.Error != nil {
		if errors.Is(result.Error, gorm.ErrRecordNotFound) {
			// 如果记录未找到，返回404状态码和相应的错误消息
			c.JSON(404, gin.H{"error": "未找到指定ID的成绩"})
		}
		return
	}

	// 如果查询成功，返回200状态码和包含成绩信息的响应体
	c.JSON(200, gin.H{
		"grade": grade,
		"msg":   "成绩查找成功",
	})
}
